Skocz do zawartości

Polecane posty

Witam jestem początkującym programistą i mam problem, otórz napisałem w Visual Studio program wahadła a dokładnie jego model i chce je teraz wprowadzić w ruch żeby poruszało się na boki jak wahadło zegara. Próbowałem z alfa+delta_ alfa ale mi to nie wychodzi czy ktoś może mi pomóc. Podspodem zamieszczam kod żródłowy.

 

 

#include <windows.h>

 

#include "glut.h"

 

 

void prostopadloscian()

{

glBegin(GL_QUADS);

glColor3f(0.0, 0.0, 0.0);

glVertex3f( 0.0, 0.0, 0.0);

glVertex3f( 0.0, 1.0, 0.0);

glVertex3f( 0.0, 1.0, 1.0);

glVertex3f( 0.0, 0.0, 1.0);

 

 

glColor3f(1.0, 1.0, 0.0);

glVertex3f( 1.0, 0.0, 1.0);

glVertex3f( 1.0, 0.0, 0.0);

glVertex3f( 1.0, 1.0, 0.0);

glVertex3f( 1.0, 1.0, 1.0);

 

 

 

glColor3f(1.0, 0.0, 0.0);

glVertex3f( 0.0, 0.0, 0.0);

glVertex3f( 1.0, 0.0, 0.0);

glVertex3f( 1.0, 1.0, 0.0);

glVertex3f( 0.0, 1.0, 0.0);

 

glColor3f(0.0, 0.0, 0.0);

glVertex3f( 0.0, 0.0, 1.0);

glVertex3f( 1.0, 0.0, 1.0);

glVertex3f( 1.0, 1.0, 1.0);

glVertex3f( 0.0, 1.0, 1.0);

 

 

glColor3f(1.0, 1.0, 0.0);

glVertex3f( 0.0, 0.0, 0.0);

glVertex3f( 0.0, 0.0, 1.0);

glVertex3f( 1.0, 0.0, 1.0);

glVertex3f( 1.0, 0.0, 0.0);

 

glColor3f(0.0, 0.0, 0.0);

glVertex3f( 0.0, 0.0, 0.0);

glVertex3f( 0.0, 1.0, 1.0);

glVertex3f( 1.0, 1.0, 1.0);

glVertex3f( 1.0, 1.0, 0.0);

 

glEnd();

}

 

 

void uchwyt()

{

glPushMatrix();

glTranslatef(0.3, 2.0, 0.65);

glScalef(0.3, 2.0, 0.2);

prostopadloscian();

glPopMatrix();

 

}

 

 

void przdłużenie()

{

glPushMatrix();

glTranslatef(0.1, 0.0, 0.0);

uchwyt();

glPopMatrix();

glPushMatrix();

glTranslatef(-0.9, 2.0, 0.3);

glScalef(2.5, -1.0, 0.9);

prostopadloscian();

glPopMatrix();

glPushMatrix();

glTranslatef(-0.2, 4.0, 0.6);

glScalef(1.8, 0.2, 0.2);

prostopadloscian();

glPopMatrix();

}

 

 

 

void wahadło()

{

 

glPushMatrix();

glTranslatef(-1.0, 2.0, 4.2);

glRotatef(-45.0, 0.0, 1.0, 0.0);

glTranslatef(-0.95, 0.0, -0.95);

przdłużenie();

glPopMatrix();

}

 

 

 

void start()

{

glClearColor(1.0,1.0,1.0,1.0);

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

glEnable(GL_DEPTH_TEST);

glMatrixMode(GL_PROJECTION);

glLoadIdentity();

gluPerspective(50.0, 1.0, 0.1, 30.0);

gluLookAt(10.0, 10.0, 12.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);

glMatrixMode(GL_MODELVIEW);

glLoadIdentity();

wahadło();

glFlush();

}

 

void main(int argc, char** argv)

{

glutInit(&argc, argv);

glutInitDisplayMode(GLUT_RGB | GLUT_SINGLE);

glutInitWindowSize(800,600);

glutInitWindowPosition(100,100);

glutCreateWindow("Wahadło");

glutDisplayFunc(start);

glutMainLoop();

}

Udostępnij ten post


Link to postu
Udostępnij na innych stronach

Cześć,

rozumiem że nie chcesz symulować prawdziwego wahadła matematycznego (albo nie daj Boże fizycznego ;)), tylko zrobić animację wahadła?

W tym celu rysujesz sobie wahadło biegnące od punktu vertex(0, 0, 0) do np vertex(0, -5, 0) - na początek może to być po prostu zwykła linia GL_LINES, a animujesz go przy użyciu np funkcji sinus;

czyli:

 

//begin scene

 

glLoadIdentity();

static int counter = 0;

// wychylenie max 30 stopni

glRotatef(0, 0, 30.0 * sin(counter * 3.1415 / 180.0))

glBegin(GL_LINES);

glVertex3f(0,0,0);

glVertex3f(0,-5,0);

glEnd();

counter++;

 

//end scene

 

Tak bym to widział, w najprostszym ujęciu ;)

Udostępnij ten post


Link to postu
Udostępnij na innych stronach

Co wam z tym wrzucaniem kodu bez tagów :/ ?

 

"Mam problem, patrzcie:"

 

 

 

# -*- coding: utf-8 -*-

import math

 

from Vector import Vector

 

class PhysicsEngine:

def __init__(self,jedi,blasterManager,clashManager):

self.blasters=blasterManager.blasters

self.clashManager=clashManager

self.drop_blasters=[]

self.jedi=jedi

 

self.Iterations=10

self.step_size=1.0/float(self.Iterations)

 

self.blaster_segments=((0,1),(1,2),(2,3),(3,0))

self.ls_segments=((2,0),(1,3),(0,1),(2,3))

self.jedi_segments=((0,1),(1,3),(3,2),(2,0))

#print self.segmentsCrossingPoint((2.0,2.0),(4.0,-3.0),(7.0,1.0),(2.0,-2.0))

#print self.intersect(Vector(1.0,1.0),Vector(3.0,3.0),Vector(1.0,2.0),Vector(4.0,10.0))

def angleToVec(self,angle):

return Vector(-math.sin(math.radians(angle)),math.cos(math.radians(angle))) # blasters rest position is vertical (-sin...)

def vecToAngle(self,V):

return math.degrees(math.atan2(V.Y,V.X))-90.0 # blasters rest position is vertical (-90)

def segmentNormal(self,A,B):

return A[1]-B[1],B[0]-A[0]

def segmentsCrossingPoint(self,A,B,C,D):

ABa=A[1]-B[1]

ABb=B[0]-A[0]

ABc=A[1]*(A[0]-B[0])+A[0]*(B[1]-A[1])

 

CDa=C[1]-D[1]

CDb=D[0]-C[0]

CDc=C[1]*(C[0]-D[0])+C[0]*(D[1]-C[1])

 

wAB=ABa*CDb-CDa*ABb

wBC=ABb*CDc-CDb*ABc

wCA=ABc*CDa-CDc*ABa

 

if wAB!=0:

return wBC/wAB,wCA/wAB

else:

return 0.0,0.0

 

def segmentCenter(self,A,B):

return 0.5*(A[0]+B[0]), 0.5*(A[1]+B[1])

 

def ccw(self,A,B,C):

return (C.Y-A.Y)*(B.X-A.X) > (B.Y-A.Y)*(C.X-A.X)

 

def intersect(self,A,B,C,D):

return self.ccw(A,C,D) != self.ccw(B,C,D) and self.ccw(A,B,C) != self.ccw(A,B,D)

 

def SegmentToSegmentCollision(self,S1A,S1B,S2A,S2B):

return self.intersect(Vector(S1A),Vector(S1B),Vector(S2A),Vector(S2B))

 

 

def step(self):

for I in range(0,self.Iterations):

self.jedi.process(self.step_size)

 

for blaster in self.blasters:

if not blaster.reflected:

blaster.shift(self.step_size)

if self.RectToRectCollision(self.jedi.ls_bbox,blaster.bbox):

self.jedi.refresh_ls_bbox()

blaster.setRotation(blaster.angle)

left,right,top,bottom=False,False,False,False

 

for bl_segment in self.blaster_segments:

if self.SegmentToSegmentCollision(self.jedi.ls_bbox[self.ls_segments[0][0]],self.jedi.ls_bbox[self.ls_segments[0][1]],

blaster.bbox[bl_segment[0]],blaster.bbox[bl_segment[1]]):

#angle=2.0*self.jedi.ls_rot-blaster.angle

#angle=self.jedi.ls_rot # jak walnie w czubek

left=True

point1=self.segmentsCrossingPoint(blaster.bbox[bl_segment[0]],blaster.bbox[bl_segment[1]],

self.jedi.ls_bbox[self.ls_segments[0][0]],self.jedi.ls_bbox[self.ls_segments[0][1]] )

break

 

for bl_segment in self.blaster_segments:

if self.SegmentToSegmentCollision(self.jedi.ls_bbox[self.ls_segments[1][0]],self.jedi.ls_bbox[self.ls_segments[1][1]],

blaster.bbox[bl_segment[0]],blaster.bbox[bl_segment[1]]):

right=True

point1=self.segmentsCrossingPoint(blaster.bbox[bl_segment[0]],blaster.bbox[bl_segment[1]],

self.jedi.ls_bbox[self.ls_segments[1][0]],self.jedi.ls_bbox[self.ls_segments[1][1]] )

break

for bl_segment in self.blaster_segments:

if self.SegmentToSegmentCollision(self.jedi.ls_bbox[self.ls_segments[2][0]],self.jedi.ls_bbox[self.ls_segments[2][1]],

blaster.bbox[bl_segment[0]],blaster.bbox[bl_segment[1]]):

top=True

point2=self.segmentsCrossingPoint(blaster.bbox[bl_segment[0]],blaster.bbox[bl_segment[1]],

self.jedi.ls_bbox[self.ls_segments[2][0]],self.jedi.ls_bbox[self.ls_segments[2][1]] )

break

for bl_segment in self.blaster_segments:

if self.SegmentToSegmentCollision(self.jedi.ls_bbox[self.ls_segments[3][0]],self.jedi.ls_bbox[self.ls_segments[3][1]],

blaster.bbox[bl_segment[0]],blaster.bbox[bl_segment[1]]):

bottom=True

point2=self.segmentsCrossingPoint(blaster.bbox[bl_segment[0]],blaster.bbox[bl_segment[1]],

self.jedi.ls_bbox[self.ls_segments[3][0]],self.jedi.ls_bbox[self.ls_segments[3][1]] )

break

 

if top and left:

blaster.linearVelocity.X,blaster.linearVelocity.Y=self.segmentNormal(self.jedi.ls_bbox[self.ls_segments[0][0]],self.jedi.ls_bbox[self.ls_segments[0][1]])

angle=self.vecToAngle(blaster.linearVelocity)

angle-=45.0

blaster.linearVelocity=self.angleToVec(angle)

point=self.segmentCenter(point1,point2)

elif top and right:

blaster.linearVelocity.X,blaster.linearVelocity.Y=self.segmentNormal(self.jedi.ls_bbox[self.ls_segments[1][0]],self.jedi.ls_bbox[self.ls_segments[1][1]])

angle=self.vecToAngle(blaster.linearVelocity)

angle+=45.0

blaster.linearVelocity=self.angleToVec(angle)

point=self.segmentCenter(point1,point2)

elif bottom and left:

blaster.linearVelocity.X,blaster.linearVelocity.Y=self.segmentNormal(self.jedi.ls_bbox[self.ls_segments[0][0]],self.jedi.ls_bbox[self.ls_segments[0][1]])

angle=self.vecToAngle(blaster.linearVelocity)

angle+=45.0

blaster.linearVelocity=self.angleToVec(angle)

point=self.segmentCenter(point1,point2)

elif bottom and right:

blaster.linearVelocity.X,blaster.linearVelocity.Y=self.segmentNormal(self.jedi.ls_bbox[self.ls_segments[1][0]],self.jedi.ls_bbox[self.ls_segments[1][1]])

angle=self.vecToAngle(blaster.linearVelocity)

angle-=45.0

blaster.linearVelocity=self.angleToVec(angle)

point=self.segmentCenter(point1,point2)

elif left:

blaster.linearVelocity.X,blaster.linearVelocity.Y=self.segmentNormal(self.jedi.ls_bbox[self.ls_segments[0][0]],self.jedi.ls_bbox[self.ls_segments[0][1]])

point=point1

elif right:

blaster.linearVelocity.X,blaster.linearVelocity.Y=self.segmentNormal(self.jedi.ls_bbox[self.ls_segments[1][0]],self.jedi.ls_bbox[self.ls_segments[1][1]])

point=point1

elif top:

angle=self.jedi.ls_rot

blaster.linearVelocity=self.angleToVec(angle)

point=point2

elif bottom:

angle=self.jedi.ls_rot+180.0

blaster.linearVelocity=self.angleToVec(angle)

point=point2

 

if (left,right,top,bottom)!=(False,False,False,False):

blaster.setRotation(self.vecToAngle(blaster.linearVelocity))

blaster.linearVelocity.Normalize()

blaster.linearVelocity*=0.3

blaster.reflected=True

self.jedi.doReflect()

self.clashManager.appendClash(point)

 

if self.RectToRectCollision(self.jedi.bbox,blaster.bbox):

self.jedi.getHit()

for jedi_segment in self.jedi_segments:

for bl_segment in self.blaster_segments:

if self.SegmentToSegmentCollision(self.jedi.bbox[jedi_segment[0]],self.jedi.bbox[jedi_segment[1]],

blaster.bbox[bl_segment[0]],blaster.bbox[bl_segment[1]]):

bottom=True

point=self.segmentsCrossingPoint(blaster.bbox[bl_segment[0]],blaster.bbox[bl_segment[1]],

self.jedi.bbox[jedi_segment[0]],self.jedi.bbox[jedi_segment[1]] )

blaster.reflected=True

break

if blaster.reflected:

self.clashManager.appendHit(point)

break

self.drop_blasters.append(blaster)

 

for blaster in self.drop_blasters:

self.blasters.remove(blaster)

self.drop_blasters=[]

 

def appendBlaster(self,blaster):

self.blasters.append(blaster)

 

def reorganize_points(self,rect): # cztery punkty w kolejnosci: gorny lewy, gorny prawy, dolny lewy, dolny prawy

rect.sort(cmp=lambda x,y: cmp(y[1],x[1]))

for i in [0,2]:

if rect[0]>rect[i+1][0]:

tmp=rect[i+1]

rect[i+1]=rect

rect=tmp

def RectToRectCollision(self,A,B):

#Setting Up

self.reorganize_points(A)

self.reorganize_points(B)

#Step 1 okreslenie osi

Axis=[]

Axis.append([A[1][0] - A[0][0],A[1][1] - A[0][1]])

Axis.append([A[1][0] - A[3][0],A[1][1] - A[3][1]])

Axis.append([b[0][0] - B[2][0],B[0][1] - B[2][1]])

Axis.append([b[0][0] - B[1][0],B[0][1] - B[1][1]])

for axis in Axis:

scalarsA=[]

scalarsB=[]

for point in A:

#Step 2 projekcja wektorow reprezentujacych cztery katy kazdego prostokata na kazdej osi

tmp=(point[0]*axis[0]+point[1]*axis[1])/(axis[0]**2+axis[1]**2)

x=axis[0]*tmp

y=axis[1]*tmp

#Step 3 obliczanie wartosci skalarnej

scalarsA.append(x*axis[0]+y*axis[1])

for point in B:

#Step 2 projekcja wektorow reprezentujacych cztery katy kazdego prostokata na kazdej osi

tmp=(point[0]*axis[0]+point[1]*axis[1])/(axis[0]**2+axis[1]**2)

x=axis[0]*tmp

y=axis[1]*tmp

#Step 3 obliczanie wartosci skalarnej

scalarsB.append(x*axis[0]+y*axis[1])

#Step 4 sprawdzenie maksymalnej i minimalnej wartosci skalarnej

maxA=max(scalarsA)

minA=min(scalarsA)

maxB=max(scalarsB)

minB=min(scalarsB)

if minB>maxA or maxB

return False

return True

 

 

 

"dobrze się Wam czyta taki kod, bo mi znakomicie"

Udostępnij ten post


Link to postu
Udostępnij na innych stronach

B) Ma się fach...

 

Czasem dobrze jest zobaczyć "odświeżony" temat, bo widać przynajmniej, że ktoś czyta starsze posty... -_-

Udostępnij ten post


Link to postu
Udostępnij na innych stronach

No ba, na wykop trzeba dać :D

 

A poza tym to odkopał ten, który pierwszy odpowiedział ;)

Udostępnij ten post


Link to postu
Udostępnij na innych stronach

Bądź aktywny! Zaloguj się lub utwórz konto

Tylko zarejestrowani użytkownicy mogą komentować zawartość tej strony

Utwórz konto

Zarejestruj nowe konto, to proste!

Zarejestruj nowe konto

Zaloguj się

Posiadasz własne konto? Użyj go!

Zaloguj się

×